package com.sgcc.pda.hzaidl.impl;


import com.sgcc.pda.hw.ISecurityUnitManager2;
import com.sgcc.pda.hw.ReturnResult;

import org.json.JSONException;
import org.json.JSONObject;

/**
 * @创建者：suven on 2019/12/17 21:44
 * @描述：
 * @版本：1.0
 * @修改人：
 * @修改时间：
 * @修改说明：
 * @修改版本：
 */
public class SecurityUnitManager2 extends ISecurityUnitManager2.Stub {
    private static SecurityUnitManager2 mInstance;


    /**
     * 单例
     *
     * @return
     */
    public static synchronized SecurityUnitManager2 getInstance() {
        if (mInstance == null) {
            mInstance = new SecurityUnitManager2();
        }
        return mInstance;
    }

    /**
     * 获取安全单元信息
     *
     * @return 0-成功 其他-错误码
     */
    public ReturnResult getSafeUnitMessage()   {
        return HardWareUtil.requestHardwareData("unit2_getSafeUnitMessage");
    }

    /**
     * 检测登录密码
     * password  传入的密码
     *
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:
     * 0：remainCount 返回剩余验证次数
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult checkUserPassword(String password)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("password", password);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_checkUserPassword", jb.toString());
    }

    /**
     * 修改操作员密码
     *
     * @param oldPassword 原密码
     * @param newPassword 新密码
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==0
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult changePassword(String oldPassword, String newPassword)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("oldPassword", oldPassword);
            jb.put("newPassword", newPassword);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_changePassword", jb.toString());
    }

    /**
     * 应用层身份认证
     *
     * @param m1 密文m1
     * @param s1 m1签名
     * @return 0-成功 其他-错误码
     */
    public ReturnResult loginIdauth(String m1, String s1)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("m1", m1);
            jb.put("s1", s1);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_loginIdauth", jb.toString());
    }

    /**
     * 从安全单元获取随机数
     *
     * @param esamType     ESAM类型  01，操作员ESAM；02业务ESAM
     * @param randomLength 随机数长度  4，8，16
     * @return 0-成功 其他-错误码
     */
    public ReturnResult getRandomNum(String esamType, String randomLength)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("esamType", esamType);
            jb.put("randomLength", randomLength);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_getRandomNum", jb.toString());
    }

    /**
     * 锁定安全单元
     *
     * @param data 认证数据
     * @return 0-成功 其他-错误码
     */
    public ReturnResult lockingSafeUnit(String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_lockingSafeUnit", jb.toString());
    }

    /**
     * 二次发行安全单元
     *
     * @param esamType esam类型  01，C-ESAM；02Y-ESAM；
     * @param fxData   发行数据  2+N
     * @return 0-成功 其他-错误码
     */
    public ReturnResult safyUnitTwoSend(String esamType, String fxData)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("esamType", esamType);
            jb.put("fxData", fxData);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_safyUnitTwoSend", jb.toString());
    }

    /**
     * 透明转发ESAM指令
     *
     * @param esamType esam类型 01，C-ESAM；02Y-ESAM；
     * @param data     转发数据内容 转发数据长度+转发数据内容
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:rtnEsamType    esam类型 01，C-ESAM；02Y-ESAM；
     * 0:rtnData       转发返回数据内容
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult transmitEsamOrder(String esamType, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("esamType", esamType);
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_transmitEsamOrder", jb.toString());
    }

    /**
     * 转加密初始化
     *

     * @param data     转发数据内容 转发数据长度+转发数据内容
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:result 执行结果数据
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult encryptInitialize(String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_encryptInitialize", jb.toString());
    }

    /**
     * 置离线计数器
     *
     * @param data 数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==0
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult resetOflineCounter(String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_resetOflineCounter", jb.toString());
    }

    /**
     * 本地密钥计算MAC
     *
     * @param randomM 随机数M
     * @param data    2+N 数据长度+数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:mac     Mac
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult localKeyComputeMac(String randomM, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("randomM", randomM);
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_localKeyComputeMac", jb.toString());
    }

    /**
     * 本地密钥验证MAC
     *
     * @param randomM 主站身份认证时返回的随机数M
     * @param data    待计算数据
     * @param mac     已有传输MAC
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:result  验证结果
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult localKeyCheckMac(String randomM, String data, String mac)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("randomM", randomM);
            jb.put("data", data);
            jb.put("mac", mac);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_localKeyCheckMac", jb.toString());
    }

    /**
     * 会话密钥计算MAC
     *
     * @param data 2+N 数据长度+数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:mac  Mac
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult sessionKeyComputeMac(String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sessionKeyComputeMac", jb.toString());
    }

    /**
     * 会话密钥核对MAC
     *
     * @param data 待计算数据
     * @param mac  已有传输MAC
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:result 验证结果
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult sessionKeyCheckMac(String data, String mac)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
            jb.put("mac", mac);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sessionKeyCheckMac", jb.toString());
    }

    /**
     * 电能表红外认证（09、13）
     *
     * @param meterNo            表号  高位在前（非颠倒），高2字节补0x0
     * @param esamNo             ESAM序列号
     * @param mRandom1           随机数1密文
     * @param infraredAuthority1 红外认证权限1
     * @param infraredAuthority2 红外认证权限2
     * @param random2            随机数2
     * @param curTime            掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:mRandom2           随机数2密文
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterInfraredAuthentication(String meterNo, String esamNo, String mRandom1, String infraredAuthority1,
                                                    String infraredAuthority2, String random2, String curTime)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("esamNo", esamNo);
            jb.put("mRandom1", mRandom1);
            jb.put("infraredAuthority1", infraredAuthority1);
            jb.put("infraredAuthority2", infraredAuthority2);
            jb.put("random2", random2);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterInfraredAuthentication", jb.toString());
    }

    /**
     * 电能表红外认证（09、13）
     *
     * @param meterNo            表号  高位在前（非颠倒），高2字节补0x0
     * @param esamNo             ESAM序列号
     * @param mRandom1           随机数1密文
     * @param infraredAuthority1 红外认证权限1
     * @param infraredAuthority2 红外认证权限2
     * @param random2            随机数2
     * @param curTime            掌机当前时间  YYMMDDhhmmss
     * @param type               公私钥标志 0为公钥，1为私钥
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:mRandom2           随机数2密文
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterInfraredAuthentication1(String meterNo, String esamNo, String mRandom1, String infraredAuthority1,
                                                     String infraredAuthority2, String random2, String curTime, String type)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("esamNo", esamNo);
            jb.put("mRandom1", mRandom1);
            jb.put("infraredAuthority1", infraredAuthority1);
            jb.put("infraredAuthority2", infraredAuthority2);
            jb.put("random2", random2);
            jb.put("curTime", curTime);

            jb.put("type", type);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterInfraredAuthentication1", jb.toString());
    }

    /**
     * 远程身份认证（09、13）
     *
     * @param meterNo                 表号 高位在前（非颠倒），高2字节补0x00；
     * @param authenticationAuthority 身份认证权限
     * @param curTime                 掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:cipher                  身份认证密文
     * 1:random1                 随机数1
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult remoteAuthentication(String meterNo, String authenticationAuthority, String curTime, String keyType)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("authenticationAuthority", authenticationAuthority);
            jb.put("curTime", curTime);
            jb.put("keyType", keyType);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_remoteAuthentication", jb.toString());
    }

    /**
     * 电能表控制（09、13）
     *
     * @param meterNo                表号  高位在前（非颠倒），高2字节补0x00
     * @param random                 随机数  身份认证产生的随机数
     * @param remoteControlAuthority 远程控制权限
     * @param orderCode              命令码
     * @param endTime                截止时间（yyMMddhhmmss 6字节）+4字节MAC
     * @param mac1                   4字节MAC
     * @param curTime                掌机当前时间
     * @param isAgMeter              是否为农排表控制
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:cipher                 控制数据密文
     * 1:mac                    MAC
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterControl(String meterNo, String random, String remoteControlAuthority, String orderCode,
                                     String endTime, String mac1, String curTime, boolean isAgMeter)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("remoteControlAuthority", remoteControlAuthority);

            jb.put("orderCode", orderCode);
            jb.put("endTime", endTime);


            jb.put("mac1", mac1);
            jb.put("curTime", curTime);
            jb.put("isAgMeter", isAgMeter);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterControl", jb.toString());
    }

    /**
     * 透明转发ESAM指令
     *
     * @param meterNo        表号  高位在前（非颠倒），高2字节补0x00
     * @param random         随机数  身份认证产生的随机数
     * @param paramAuthority 参数设置权限
     * @param paramType      参数类型 03，二类参数； 05，一类参数； 06，一套费率；  07，备用套费率；
     * @param dataSign       数据标识
     * @param paramValue     参数值
     * @param mac1           MAC  参数类型为05、06、07时，MAC值是参数值的MAC， 参数类型为03时，MAC值是数据标示及参数值的MAC
     * @param curTime        掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:length         长度		包含MAC的长度
     * 1:param          参数明文或密文
     * 2:mac            MAC
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterParamSet(String meterNo, String random, String paramAuthority,
                                      String paramType, String dataSign, String paramValue, String mac1, String curTime)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("paramAuthority", paramAuthority);
            jb.put("paramType", paramType);
            jb.put("dataSign", dataSign);
            jb.put("paramValue", paramValue);
            jb.put("mac1", mac1);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterParamSet", jb.toString());
    }

    /**
     * 电能表校时（09、13）
     *
     * @param meterNo        表号  高位在前（非颠倒），高2字节补0x00
     * @param random         随机数  身份认证产生的随机数
     * @param checkAuthority 校时权限
     * @param dataSign       数据标识
     * @param paramValue     参数值
     * @param mac1           MAC值是数据标示及参数值的MAC
     * @param week           星期
     * @param curTime        掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==3
     * 0:length         长度		包含MAC的长度
     * 1:cipher         校时数据密文
     * 2:mac            MAC
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterCheckTime(String meterNo, String random, String checkAuthority,
                                       String dataSign, String paramValue, String mac1, String week, String curTime)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("checkAuthority", checkAuthority);
            jb.put("week", week);
            jb.put("dataSign", dataSign);
            jb.put("paramValue", paramValue);
            jb.put("mac1", mac1);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterCheckTime", jb.toString());
    }

    /**
     * 电能表密钥更新(09)
     *
     * @param meterNo      表号  高位在前（非颠倒），高2字节补0x00
     * @param random       随机数  身份认证产生的随机数
     * @param athorityData 权限数据
     * @param secret       密钥密文
     * @param curTime      掌机当前时间  YYMMDDhhmmss
     * @param keySign      密钥状态标志位  00：密钥恢复  01：密钥下装
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:length       数据长度
     * 1:cipher       密钥数据  密钥信息（4）+MAC（4）+密钥密文（32）
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult secretUpdate09(String meterNo, String random, String athorityData,
                                       String secret, String curTime, String keySign)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("athorityData", athorityData);

            jb.put("secret", secret);
            jb.put("keySign", keySign);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_secretUpdate09", jb.toString());
    }

    /**
     * 电能表密钥更新(13)
     *
     * @param meterNo      表号  高位在前（非颠倒），高2字节补0x00
     * @param random       随机数  身份认证产生的随机数
     * @param athorityData 权限数据
     * @param cipher       密钥密文
     * @param curTime      掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:secret       密钥数据块   2+N  数据长度+密钥1…密钥N
     * 1:mac          MAC
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult secretUpdate13(String meterNo, String random, String athorityData,
                                       String cipher, String curTime)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("athorityData", athorityData);

            jb.put("cipher", cipher);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_secretUpdate13", jb.toString());
    }

    /**
     * 电能表开户充值（09、13）
     *
     * @param meterNo       表号  高位在前（非颠倒），高2字节补0x00
     * @param random        随机数  身份认证产生的随机数
     * @param athorityData1 权限数据1
     * @param athorityData2 权限数据2
     * @param rechargeData  开户数据 数据标识（4字节）+购电金额（4字节）+购电次数（4字节）+MAC1（4字节）+客户编号（6字节）+MAC2（4字节）
     * @param curTime       掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==5
     * 0:rrechargeMoney 充值金额M；
     * 1:rbuyNum        购电次数
     * 2:rmac1          MAC
     * 3:ruserNum       客户编号
     * 4:rmac2          MAC
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterRecharge1(String meterNo, String random, String athorityData1,
                                       String athorityData2, String rechargeData, String curTime)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("athorityData1", athorityData1);
            jb.put("athorityData2", athorityData2);
            jb.put("rechargeData", rechargeData);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterRecharge1", jb.toString());
    }

    /**
     * 电能表开户充值（09、13）
     *
     * @param meterNo       表号  高位在前（非颠倒），高2字节补0x00
     * @param random        随机数  身份认证产生的随机数
     * @param athorityData1 权限数据1
     * @param athorityData2 权限数据2
     * @param taskData      开户数据 数据标识（4字节）+购电金额（4字节）+购电次数（4字节）+MAC1（4字节）+客户编号（6字节）+MAC2（4字节）
     * @param curTime       掌机当前时间  YYMMDDhhmmss
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:rechargeData  安全单元返回数据
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterRecharge(String meterNo, String random, String athorityData1,
                                      String athorityData2, String taskData, String curTime)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("random", random);
            jb.put("athorityData1", athorityData1);
            jb.put("athorityData2", athorityData2);
            jb.put("taskData", taskData);
            jb.put("curTime", curTime);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterRecharge", jb.toString());
    }

    /**
     * 与外设进行秘钥协商，获取M1和Mac1
     *
     * @param kid      秘钥kid。
     * @param wesamNum wesam芯片序列号
     * @param hhjsq    外设返回的会话计数器
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:M1       安全单元返回的密文1
     * 1:Mac1     安全单元返回的Mac1
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult wsSecretXieShang(String kid, String wesamNum, String hhjsq)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("kid", kid);
            jb.put("wesamNum", wesamNum);
            jb.put("hhjsq", hhjsq);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_wsSecretXieShang", jb.toString());
    }

    /**
     * 与外设进行秘钥协商确认
     *
     * @param kid      秘钥kid。
     * @param wesamNum wesam芯片序列号
     * @param M2       外设返回的密文2
     * @param Mac2     外设返回的Mac2
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==0
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult wsSecretXieShangConfirm(String kid, String wesamNum, String M2, String Mac2)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("kid", kid);
            jb.put("wesamNum", wesamNum);
            jb.put("M2", M2);
            jb.put("Mac2", Mac2);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_wsSecretXieShangConfirm", jb.toString());
    }

    /**
     * 与外设秘钥协商后进行加密数据
     *
     * @param wsType 读取外设信息时返回的类型
     * @param data   要加密的数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:encryptDataLength 返回的加密后数据的长度  密文+mac的长度
     * 1:encryptData       返回的加密后的数据  密文+mac的数据
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult wsEncryptData(String wsType, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("wsType", wsType);
            jb.put("data", data);

        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_wsEncryptData", jb.toString());
    }

    /**
     * 与外设秘钥协商后进行解密数据
     *
     * @param wsType esam类型 01，C-ESAM；02Y-ESAM；
     * @param encryptData     转发数据内容 转发数据长度+转发数据内容
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==2
     * 0:dataLength 返回的解密后数据的长度
     * 0:data       返回的解密后的数据     明文
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult wsDecryptData(String wsType, String encryptData)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("wsType", wsType);
            jb.put("encryptData", encryptData);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_wsDecryptData", jb.toString());
    }

    /**
     * 698电能表会话协商验证
     *
     * @param secretData  密钥包
     * @param meterNo     若为公钥：使用ESAM序列号   若为私钥：用表号高位在前（非颠倒），高2字节补0x00；
     * @param secretSign  密钥标识
     * @param sessionData 会话数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==0
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterSessionTalk698Check(String secretData, String meterNo, String secretSign,
                                                 String sessionData)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("secretData", secretData);
            jb.put("meterNo", meterNo);
            jb.put("secretSign", secretSign);

            jb.put("sessionData", sessionData);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterSessionTalk698Check", jb.toString());
    }

    /**
     * 698电能表安全数据生成
     *
     * @param taskData 主站任务数据   1字节安全模式字+任务参数类型+2字节应用层数据长度+应用层数据+4字节保护码（根据应用层数据长度可得知整个任务数据长度）
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:rtnData       转发返回数据内容
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterSafeData698(String taskData)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", taskData);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterSafeData698", jb.toString());
    }

    /**
     * 698电能表安全传输解密
     *
     * @param secretData 电表返回的密文链路数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:rtnData       应用层数据明文
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterSafeTransJieMi698(String secretData)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", secretData);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterSafeTransJieMi698", jb.toString());
    }

    /**
     * 698电能表抄读数据验证
     *
     * @param disFactor 分散因子
     * @param data      应用层数据明文
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==1
     * 0:rtnData   返回的应用层数据明文
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterDataCheck698(String disFactor, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("disFactor", disFactor);
            jb.put("data", data);

        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterDataCheck698", jb.toString());
    }

    /**
     * 698电能表抄读ESAM参数验证
     *
     * @param meterNo 若为公钥：使用ESAM序列号   若为私钥：用表号高位在前（非颠倒），高2字节补0x00；
     * @param oad     OAD
     * @param data    应用层数据
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:   size==0
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult meterEsamParamCheck698(String meterNo, String oad, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("oad", oad);
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_meterEsamParamCheck698", jb.toString());
    }


    /**
     * 电子封印读认证生成token1
     *
     * @param kid   秘钥kid。
     * @param uid   分散因子
     * @param radom 随机数

     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealReadGetTokenOne(String kid, String uid, String radom)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("kid", kid);
            jb.put("uid", uid);
            jb.put("radom", radom);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealReadGetTokenOne", jb.toString());
    }


    /**
     * 电子封印读认证验证token2
     *
     * @param kid   秘钥kid。
     * @param uid   分散因子
     * @param token 电子封印返回的token2
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealReadCheckTokenTwo(String kid, String uid, String token)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("kid", kid);
            jb.put("uid", uid);
            jb.put("token", token);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealReadCheckTokenTwo", jb.toString());
    }


    /**
     * 加密数据地址（读）
     *
     * @param kid  秘钥kid。
     * @param uid  分散因子
     * @param data 待加密数据的地址

     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealReadgetMi(String kid, String uid, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("kid", kid);
            jb.put("uid", uid);
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealReadgetMi", jb.toString());
    }


    /**
     * 解密读回数据
     *
     * @param kid  秘钥kid。
     * @param uid  分散因子
     * @param data 回读的密文数据

     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealReadgetMing(String kid, String uid, String data)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("kid", kid);
            jb.put("uid", uid);
            jb.put("data", data);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealReadgetMing", jb.toString());
    }


    /**
     * 电子封印写认证生成token1
     *
     * @param uid   分散因子
     * @param radom 随机数
     * @param date  时间
     * @param auth  操作权限
     * 返回的token1
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealWriteGetTokenOne(String uid, String radom, String date, String auth)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("radom", radom);
            jb.put("uid", uid);
            jb.put("date", date);
            jb.put("auth", auth);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealWriteGetTokenOne", jb.toString());
    }


    /**
     * 电子封印写认证验证token2
     *
     * @param uid   分散因子
     * @param token 电子封印返回的token2
     * @param date  时间
     * @param auth  操作权限
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealWriteCheckTokenTwo(String uid, String token, String date, String auth)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("token", token);
            jb.put("uid", uid);
            jb.put("date", date);
            jb.put("auth", auth);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealWriteCheckTokenTwo", jb.toString());
    }


    /**
     * 加密数据地址（写）
     *
     * @param uid  分散因子
     * @param data 数据地址
     * @param date 时间
     * @param auth 操作权限
     *   返回的数据，密文
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealWritegetM1(String uid, String data, String date, String auth)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
            jb.put("uid", uid);
            jb.put("date", date);
            jb.put("auth", auth);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealWritegetM1", jb.toString());
    }


    /**
     * 加密写数据
     *
     * @param uid  分散因子
     * @param data 数据地址
     * @param date 时间
     * @param auth 操作权限
     *  返回的数据，密文
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealWritegetM2(String uid, String data, String date, String auth)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
            jb.put("uid", uid);
            jb.put("date", date);
            jb.put("auth", auth);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealWritegetM2", jb.toString());
    }


    /**
     * 解密执行结果
     *
     * @param uid  分散因子
     * @param mi   状态字密文
     * @param date 时间
     * @param auth 操作权限
     *  ming 返回的数据，状态字明文
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealWritegetMing(String uid, String mi, String date, String auth)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("mi", mi);
            jb.put("uid", uid);
            jb.put("date", date);
            jb.put("auth", auth);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealWritegetMing", jb.toString());
    }


    /**
     * 加密密钥更新数据
     *
     * @param uid  分散因子
     * @param data 数据
     * @param date 时间
     * @param auth 操作权限
     *     返回的数据，密文
     * @return 0：成功；其他-错误码
     */
    public ReturnResult sealUpdategetMi(String uid, String data, String date, String auth)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("data", data);
            jb.put("uid", uid);
            jb.put("date", date);
            jb.put("auth", auth);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_sealUpdategetMi", jb.toString());
    }

    /**
     * 获取电表控制命令密文
     *
     * @param taskSign    任务标识
     * @param random2     远程认证时电表返回的随机数2
     * @param esamNo      远程认证时电表返回的ESAM编号
     * @param meterNo     电表表号
     * @param taskData    任务数据
     * @param protectCode 任务数据保护码
     * @param controlCmd  控制数据
     * @param timeLimit   任务有效期
     * @return ReturnResult  :int code  0 成功  其他失败
     * :List<String> datas（code==0）:
     * 0：enControlData 控制命令密文
     * :List<String> datas(code==其他): size==0
     */
    public ReturnResult getRemoteControlData(String taskSign, String random2, String esamNo, String meterNo,
                                             String taskData, String protectCode, String controlCmd,
                                             String timeLimit)   {
        JSONObject jb = new JSONObject();
        try {
            jb.put("meterNo", meterNo);
            jb.put("taskSign", taskSign);
            jb.put("random2", random2);
            jb.put("esamNo", esamNo);
            jb.put("taskData", taskData);
            jb.put("protectCode", protectCode);
            jb.put("controlCmd", controlCmd);
            jb.put("timeLimit", timeLimit);
        } catch (JSONException e) {
            e.printStackTrace();
        }
        return HardWareUtil.requestHardwareData("unit2_getRemoteControlData", jb.toString());
    }


}
